When navigating at sea, sailors need to know where it is safe to travel and where underwater dangers such as rocks, reefs or wrecks may be hiding beneath the surface. Not every hazard can be seen from a boat, so navigation buoys are used to mark hazards and guide vessels safely around them.

In this Python challenge, you will investigate a particular type of navigation marker: the cardinal buoy. You will then use selection (if statements) and coordinates to write a program that automatically chooses the correct cardinal buoy based on its position relative to an underwater danger.

What are Cardinal Buoys?

Cardinal buoys are used to indicate where the safe water lies in relation to a hazard. They are named after the four cardinal points of a compass: North – East – South – West

The name of the buoy tells a sailor which side of the buoy they should pass. For example, a North Cardinal Buoy tells you that the safest/deepest water is to the north of the buoy, while a West Cardinal Buoy indicates that you should pass to its west.

Cardinal buoys are easy to recognise because they use distinctive black and yellow markings, together with two black triangles pointing either up ▲ or down ▼.

• North: black above yellow, with both triangles pointing upwards.
• East: black-yellow-black, with the triangles pointing away from each other.
• South: yellow above black, with both triangles pointing downwards.
• West: yellow-black-yellow, with the triangles pointing towards each other.

These markings allow sailors to quickly identify the buoy and determine where the safe water is located.

The Coding Challenge

For this challenge, an underwater rock is positioned in the centre of the screen. Your program will randomly generate a position (x, y) for a new buoy somewhere around this danger.
Your task is to determine which of the four cardinal buoys should be placed at that position.

Some of the Python code has already been provided for you. This includes the code required to draw the sea and underwater danger, as well as a subroutine called:

addBuoy(cardinalPoint, x, y)

The subroutine requires three parameters:

1. The type of cardinal buoy: “North”, “South”, “East” or “West”
2. Its x-coordinate
3. Its y-coordinate

For example, the following code will draw a West Cardinal Buoy at coordinates (-100, 20):

addBuoy("West", -100, 20)

Note that the centre of the screen represents the danger and has coordinates (0, 0).

Your task consist of using the Python IDE below to complete the code needed to randomly generate a set of (x,y) coordinates (each between -150 and 150).

import random
x = random.randint(-150,150)
y = random.randint(-150,150)

Then you will need to implement the following flowchart using Python code to let the computer decide which cardinal point to use based on its randomly generated position.

Note that you will need to use the abs() function in python to get the absolute value.

e.g.

if x<0 and abs(x) >= abs(y):
   addBuoy("West", x, y)

Python Code:

Compete the code below:

Solution...

The solution for this challenge is available to full members!
Find out how to become a member:
➤ Members' Area

When sailing, the direction in which a boat can travel depends on the direction of the wind. Sailors describe the angle between the boat and the wind using different points of sailing, such as close-hauled, beam reach, broad reach and run.

In this Python challenge, you are going to write a program that uses the direction of the boat and the direction of the wind to work out the boat’s current point of sailing.

Boat and Wind Directions

Directions will be represented using angles between 0° and 360°:

• 0° = North
• 90° = East
• 180° = South
• 270° = West

Your program should start by asking the user to enter two values:

1. The direction of the boat
2. The direction the wind is coming from

For example:
Boat direction: 120°
Wind direction: 40°

We will use these two values to calculate the relative angle of the wind (relative to the direction of the boat). However, you cannot simply subtract these two values. Because directions wrap around at 360°, your program needs to calculate the relative wind angle correctly using the following algorithm:

For example, a boat travelling at 20° with the wind coming from 340° has a relative wind angle of only 40°.
The sign of the angle tells you which side of the boat the wind is coming from, while its magnitude tells you the boat’s point of sailing.

Points of Sailing

Once you have calculated the relative wind angle, use selection (if, elif and else) to work out the correct point of sailing.

The same ranges apply on either side of the boat (for negative relative angles) This means, for example, that both +90° and −90°, represent a beam reach.

Python Challenge

Write a Python program that:

Asks the user for the boat direction between 0° and 360°.
Asks for the wind direction between 0° and 360°.
Calculates the relative angle of the wind.
Displays the relative wind angle.
Uses an if / elif / else selection to identify the correct point of sailing.
Displays the result to the user.

For example, your program might produce the following output:

Enter the boat direction (0-360): 120
Enter the wind direction (0-360): 40

Relative wind angle: -80 degrees
Point of sailing: Beam reach

Python Code

Complete the Python code below:

Online Points of Sailing Page

You can use our online interactive Points of Sailing page to understand more about the points of sailing and the position of the main sail and the jib on a sailing boat. You can use this page to help you test your program for different wind directions and boat directions.

Solution...

The solution for this challenge is available to full members!
Find out how to become a member:
➤ Members' Area

Have you ever wondered how a computer keeps track of all the coloured squares on a Rubik’s Cube? Although the puzzle looks complicated, each face of the cube can actually be stored using a simple 3 × 3 two-dimensional (2D) array.

Instead of storing colours directly, programmers often represent each colour using a number from 1 to 6. For example:

1: red
2: white
3: yellow
4: orange
5: green
6: blue

A single face of the cube could therefore be stored like this:

In this Python challenge, your task is to complete a program that rotates one face of the Rubik’s Cube by 90 degrees. Using the flowchart provided, you will implement the algorithm needed to perform either a clockwise or an anti-clockwise rotation of the 2D array.

As you work through the challenge, you will discover how rows and columns change position during a rotation and how nested loops can be used to move data from one array into another. This is a great opportunity to practise working with 2D arrays, nested loops, indexing, and algorithmic thinking—skills that are widely used in computer graphics, games, image processing and artificial intelligence.

Algorithm Flowchart

Here is the flowchart to implement a rotation on a 2D-Array:

Python Code

Complete the following code using the algorithm described in the above flowchart

Extension Challenge

Once you have successfully rotated the 3 × 3 Rubik’s Cube face, take your solution one step further. Replace the array with a 4 × 4 version and see whether your algorithm still works correctly. Does your code depend on the array always being 3 × 3, or has it been written in a way that can rotate a square array of any size?

array = [[1, 2, 1, 4],
         [5, 4, 3, 5],
         [2, 1, 6, 3],
         [1, 4, 6, 2]]

Solution...

The solution for this challenge is available to full members!
Find out how to become a member:
➤ Members' Area

Imagine being tasked with exploring a vast underground cave system where no human has ever been before. Narrow passages, uneven ceilings, jagged rocks and sudden drops make it far too dangerous for people to enter. Instead, scientists use autonomous drones to safely explore these hidden environments, mapping caves and collecting valuable data without putting anyone at risk.

In this activity, you’ll investigate the Python code used to control a cave exploration drone. Rather than being controlled by a pilot, the drone uses three infra-red distance sensors to detect obstacles in front of it. One sensor points diagonally upwards, one points straight ahead, and one points diagonally downwards. As the drone flies through the cave, these sensors constantly monitor the shape of the ceiling and the ground.

The Python program processes the information from the three sensors many times every second. If one of the sensors detects that the drone is getting too close to the cave walls, the program decides whether the drone should climb, descend or continue flying straight ahead. By repeatedly reading the sensors and adjusting its movement, the drone can navigate safely through the cave while avoiding collisions.

Here is the flowchart for the algorithm to control the drone:

As you work through the code, you will discover how programming, sensors and decision-making algorithms combine to create an autonomous system capable of reacting to its environment in real time. See if you can understand how the drone makes its decisions, then experiment with the code to improve its navigation or add your own ideas!

Python Code

Your Turn

As part of a space exploration project, an autonomous drone spacecraft will be sent on a journey through Jupiter’s asteroid belt. Your task is to reuse the Python code developed for the cave-exploration drone and adapt it for this new mission. Instead of detecting the cave’s ceiling and ground, the drone must use its three laser sensors to identify approaching asteroids and automatically adjust its vertical position to avoid a collision. Can you modify the existing navigation algorithm so the spacecraft can travel safely through space?

Python Code

You will need to update the code from line 48.

Solution...

The solution for this challenge is available to full members!
Find out how to become a member:
➤ Members' Area